Types construits : les dictionnaires

Introduction

On donne la liste suivante :

# Données sur la couleur des yeux
		
# marron = "m"
# bleu = "b"
# noisette = "n"
# verts = "v"
# gris = "g"
l = ['m', 'n', 'g', 'm', 'b', 'b', 'g', 'm', 'v', 'm', 'b', 'n', 'm', 'n', 'v', 'm', 'm', 'b', 'm', 'm', 'm', 'm', 'b', 'm', 'm', 'm', 'm', 'm', 'm', 'm', 'm', 'm']

Quelle information pouvez vous extraire de cette liste ?
Comment organiser cette information?

Si besoin, vous pouvez utiliser le site Trinket.

Les types construits : les dictionnaires Tableaux associatifs

Définition

Le dictionnaire , de type dict en Python, est une structure de données permettant d’associer des valeurs à des clés.

C'est un type de conteneur comme les list et les tuple mais ce n'est pas une séquence. Au sens où les valeurs des tableaux ne sont pas indexées par des entiers.

Les clés peuvent être de type : str, entier, flottants, tuple (à conditions que les tuples ne contiennent que des entiers, des flottants ou des n-uplets et pas des listes) ; une liste, objet mutable, ne peut pas être une clé de dictionnaire.

Les valeurs peuvent être de n'importe quel type.

Le couple clef/valeur est appelée association.
Pour écrire une association en Python, il suffit d'écrire la clé puis la valeur associée séparée du symbole :.
Un dictionnaire est un ensemble d'associations.
En Python, le dictionnaire est délimité par des accolades { et } et chaque association est séparée de la suivante par une virgule ,.

À partir d'une clé, on peut alors accéder directement à la valeur qui lui est associée.

Construire d'un bloc un dictionnaire

construire un objet dict en Python

Pour créer d'un bloc un dictionnaire, on écrit entre des accolades les couples séparés par deux points :, chaque couple étant composé d'une clé et de la valeur correspondante.

En Python, on écrira :

{clef1: valeur1, clef2: valeur2, ...}

L'ordre des différentes associations n'est pas important dans un dictionnaire, comme le montre l'exécution du code suivant :

dico1 = {"a": 1, "b": 2, "c": 3}
dico2 = {"b": 2, "c": 3, "a": 1}    # Mêmes associations mais saisies dans un ordre différent
print(dico1 == dico2)               # Affiche True : dico1 et dico2 sont considérés comme étant deux dictionnaires égaux

dico = {"yes": "oui", "no": "non", "and": "et", "nsi": "dansletop2despé", "maths": "dansletop2desspé"}

jours = {1: "lundi", 2: "mardi", 3: "mercredi", 4: "jeudi", 5: "vendredi", 6: "samedi", 7: "dimanche"}

Balzac = {
          'pnom': 'Honoré de Balzac', 
          'nais': 1799, 
          'mort': 1850, 
          'romans': ['Les Chouans', 'La Peau de chagrin', 'Les Contes drolatiques', 'Eugénie Grandet', \
                     'Le Père Goriot', 'Le Colonel Chabert', 'Le Lys dans la vallée', 'Illusions perdues', \
                     'Ursule Mirouët', 'La Cousine Bette', 'Le Cousin Pons']
         }

Pour faciliter la lecture du contenu de la liste , le symbole \ a été utilisé suivi d'un retour direct à la ligne.
Le symbole \ suivi d'un retour à ligne direct permet de continuer une instruction sur une nouvelle ligne pour améliorer la lisibilité du code.

Attention toutefois à ne pas mettre d'espace après le symbole \ sous peine d'erreur de syntaxe !

Pour chaque question, déterminer si la structure proposée est un dictionnaire et si oui identifier les clés, les valeurs et leur type.

{
 "prenoms_heros": ["Hercule", "Thésée", "Dote", "Ine", "Zion"], 
 "âge": 16,
 "1": 2023, 
 "abris": ("Zone_ama", "Abri_co", "Wharf")
}

```
{[1, 3]: "base", [x, y, z]: "objectif"}
```
```
{(1, 3): "base", (x, y, z): "objectif"}
```

{(10, 'trèfle'): 10, (9, 'trèfle'): 9, (8, 'trèfle'): 8, (7, 'trèfle'): 7}

Plusieurs de vos ami.e.s sont né.e.s durant ce mois.
Le prénom de chaque ami.e avec son jour de naissance est donné par le tableau suivant :

Prénom (de type `str`)	Jour de naissance (de type `int`)
"Emma"	15
"Abdoulaye"	1
"Liu"	26
"Dominique"	18

Écrire un dictionnaire ce_mois qui associe à chaque prénom présent dans le tableau ci-dessus le jour de naissance de cet.te ami.e.

Voici un exercice à faire en autonomie pour tester votre maîtrise sur l'écriture d'un dictionnaire.
Cet exercice est issu du site collaboratif de la forge.

Cliquer sur ce lien pour accéder à l'exercice.

Pour la première question, vous pouvez compléter le script suivant :

automate_1 = {
              (0, "t"): 1, 
              (1, "a"): 2, 
              (2, "d"): ..., 
              ...: 4, 
              ...
             }
debut_1 = 0
fin_1 = 4

Plutôt que d'écrire d'un bloc tout le dictionnaire, il existe d'autres procédés de construction d'un dictionnaire.
Une première méthode est de procéder par extension.

Création de dictionnaire par extension

Un dictionnaire vide d peut être créé en Python avec d = {}.
Pour ajouter un couple de clé/valeur à un dictionnaire d il suffit d'écrire :
```
d[nouvelle_clef] = nouvelle_valeur 			
```

On donne le dictionnaire ligue_Hatur suivant qui donne le niveau de chaque personnage d'un jeu vidéo membre de la même ligue :

ligue_Hatur = {
               'Anno_Nimes': 18, 
               'Istres_Ion': 17, 
               'Pere_Sonne': 14, 
               'Papi_net': 14, 
               'DS': 21, 
               'Andromaché': 22, 
               'Hero_Ines': 11
              }

Un nouveau personnage intègre cette ligue : 'Scythe_Oueb' de niveau 15.
Ajouter ce joueur .

exercice de renforcement

Écrire une fonction const_dico(cle, valeur) qui renvoie le dictionnaire défini par les clés et les valeurs entrées en argument sous forme de deux listes supposées de même longueur. (On suppose que la valeur d'index i doit être associée à la clé de même index).

Par exemple, si cle = ["pnom", "nais"] et si valeur = ['Honoré de Balzac', 1799], alors const_dico(cle, valeur) renvoie le dictionnaire {'pnom': 'Honoré de Balzac', 'nais': 1799}.
Aides possibles en cas de difficultés :
Une démarche possible :
1. Créer l'en-tête de la fonction.
2. Créer un dictionnaire réponse vide.
3. Balayer une des deux listes par les indices (=positions).
4. À chaque itération, rajouter une association au dictionnaire dont la clef est l'élément de la liste cle correspondant à la position du balayage et dont la valeur est l'élément de la liste valeur se trouvant en même position.
5. Tester la fonction créée à l'aide de l'exemple proposé.
En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.
Copier puis compléter le script suivant en vous servant des commentaires et du test proposé ci-dessus.
```
def const_dico(cle: list, valeur: list) -> dict:
    dico = ...
    for i in range(...): # Balayage d'une liste par les positions
        ... # Étendre le dictionnaire avec une nouvelle association 
    return dico

cle = ["pnom", "nais"]
valeur = ['Honoré de Balzac', 1799]
assert(const_dico(cle, valeur)) == {'pnom': 'Honoré de Balzac', 'nais': 1799}
```
Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.
Code de déblocage de la correction :
On donne des listes de certains joueurs de League Of Legend ainsi que leur classement et leur nombre de points :
```
pseudo = ['Major Alexander', 'KBM Wiz', 'FNC MagiFelix', 'Avalanche', 'love camile', 'Nobody']
classement = [(12, 1406), (1, 1613), (4, 1507), (9, 1429), (16, 1341), (11, 1416)]					
```
1. Quel est le type de chacun des éléments?
2. Appliquez votre fonction const_dico(cle, valeur) sur les joueurs de League Of Legend.
Code de déblocage de la correction :

Création en compréhension

Comme avec les listes, il est possible de construire des dictionnaires en compréhension.

Prendre le temps de lire et de comprendre les trois scripts ci-dessous puis écrire le contenu du dictionnaire construit aux lignes 1 et 3.

dico1 = {x: x**2 for x in range(1, 5)}
jours = 'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'
dico = {i+1: jours[i] for i in range(len(jours))}

Une fois vos explications écrites, exécuter les scripts précédents afin de vérifier la compréhension correcte.

Si besoin, vous pouvez utiliser le site Trinket pour cette exécution.

Cryptographie

La fonction chr()

Pour cet exercice nous allons utiliser la fonction chr de Python qui prend en argument un entier (codé en décimal) et qui renvoie le caractère ASCII associé.

Voici une table ASCII

Décimal   Octal   Hex  Binaire   Caractère
-------   -----   ---  --------    ------
000      000    00   00000000      NUL    (Null char.)
001      001    01   00000001      SOH    (Start of Header)
002      002    02   00000010      STX    (Start of Text)
003      003    03   00000011      ETX    (End of Text)
004      004    04   00000100      EOT    (End of Transmission)
005      005    05   00000101      ENQ    (Enquiry)
006      006    06   00000110      ACK    (Acknowledgment)
007      007    07   00000111      BEL    (Bell)
008      010    08   00001000       BS    (Backspace)
009      011    09   00001001       HT    (Horizontal Tab)
010      012    0A   00001010       LF    (Line Feed)
011      013    0B   00001011       VT    (Vertical Tab)
012      014    0C   00001100       FF    (Form Feed)
013      015    0D   00001101       CR    (Carriage Return)
014      016    0E   00001110       SO    (Shift Out)
015      017    0F   00001111       SI    (Shift In)
016      020    10   00010000      DLE    (Data Link Escape)
017      021    11   00010001      DC1    (XON)(Device Control 1)
018      022    12   00010010      DC2    (Device Control 2)
019      023    13   00010011      DC3    (XOFF)(Device Control 3)
020      024    14   00010100      DC4    (Device Control 4)
021      025    15   00010101      NAK    (Negative Acknowledgement)
022      026    16   00010110      SYN    (Synchronous Idle)
023      027    17   00010111      ETB    (End of Trans. Block)
024      030    18   00011000      CAN    (Cancel)
025      031    19   00011001       EM    (End of Medium)
026      032    1A   00011010      SUB    (Substitute)
027      033    1B   00011011      ESC    (Escape)
028      034    1C   00011100       FS    (File Separator)
029      035    1D   00011101       GS    (Group Separator)
030      036    1E   00011110       RS    (Request to Send)(Record Separator)
031      037    1F   00011111       US    (Unit Separator)
032      040    20   00100000       SP    (Space)
033      041    21   00100001        !    (exclamation mark)
034      042    22   00100010        "    (double quote)
035      043    23   00100011        #    (number sign)
036      044    24   00100100        $    (dollar sign)
037      045    25   00100101        %    (percent)
038      046    26   00100110        &    (ampersand)
039      047    27   00100111        '    (single quote)
040      050    28   00101000        (    (left opening parenthesis)
041      051    29   00101001        )    (right closing parenthesis)
042      052    2A   00101010        *    (asterisk)
043      053    2B   00101011        +    (plus)
044      054    2C   00101100        ,    (comma)
045      055    2D   00101101        -    (minus or dash)
046      056    2E   00101110        .    (dot)
047      057    2F   00101111        /    (forward slash)
048      060    30   00110000        0
049      061    31   00110001        1
050      062    32   00110010        2
051      063    33   00110011        3
052      064    34   00110100        4
053      065    35   00110101        5
054      066    36   00110110        6
055      067    37   00110111        7
056      070    38   00111000        8
057      071    39   00111001        9
058      072    3A   00111010        :    (colon)
059      073    3B   00111011        ;    (semi-colon)
060      074    3C   00111100        <    (less than sign)
061      075    3D   00111101        =    (equal sign)
062      076    3E   00111110        >    (greater than sign)
063      077    3F   00111111        ?    (question mark)
064      100    40   01000000        @    (AT symbol)
065      101    41   01000001        A
066      102    42   01000010        B
067      103    43   01000011        C
068      104    44   01000100        D
069      105    45   01000101        E
070      106    46   01000110        F
071      107    47   01000111        G
072      110    48   01001000        H
073      111    49   01001001        I
074      112    4A   01001010        J
075      113    4B   01001011        K
076      114    4C   01001100        L
077      115    4D   01001101        M
078      116    4E   01001110        N
079      117    4F   01001111        O
080      120    50   01010000        P
081      121    51   01010001        Q
082      122    52   01010010        R
083      123    53   01010011        S
084      124    54   01010100        T
085      125    55   01010101        U
086      126    56   01010110        V
087      127    57   01010111        W
088      130    58   01011000        X
089      131    59   01011001        Y
090      132    5A   01011010        Z
091      133    5B   01011011        [    (left opening bracket)
092      134    5C   01011100        \    (back slash)
093      135    5D   01011101        ]    (right closing bracket)
094      136    5E   01011110        ^    (caret cirumflex)
095      137    5F   01011111        _    (underscore)
096      140    60   01100000        `
097      141    61   01100001        a
098      142    62   01100010        b
099      143    63   01100011        c
100      144    64   01100100        d
101      145    65   01100101        e
102      146    66   01100110        f
103      147    67   01100111        g
104      150    68   01101000        h
105      151    69   01101001        i
106      152    6A   01101010        j
107      153    6B   01101011        k
108      154    6C   01101100        l
109      155    6D   01101101        m
110      156    6E   01101110        n
111      157    6F   01101111        o
112      160    70   01110000        p
113      161    71   01110001        q
114      162    72   01110010        r
115      163    73   01110011        s
116      164    74   01110100        t
117      165    75   01110101        u
118      166    76   01110110        v
119      167    77   01110111        w
120      170    78   01111000        x
121      171    79   01111001        y
122      172    7A   01111010        z
123      173    7B   01111011        {    (left opening brace)
124      174    7C   01111100        |    (vertical bar)
125      175    7D   01111101        }    (right closing brace)
126      176    7E   01111110        ~    (tilde)
127      177    7F   01111111      DEL    (delete)

Quels sont les entiers qui code l'alphabet en lettre capitale?
Sans exécuter le script, deviner quel est l'affichage obtenu par le script print(chr(65)).
Quel script suffit-il écrire pour obtenir l'affichage de l'acronyme "NSI" ?
Écrire le script Python qui permet de créer une structure de données de type dict qui doit être :

Aides possibles en cas de difficultés :
Pour créer le dictionnaire associant à chaque lettre sa position dans l'alphabet réduite de 1, il suffit de le faire par compréhension avec le script suivant à compléter :
```
alpha = {chr(...): ... for i in range(...)}
print(alpha)
```
Autre méthode possible si vous ne réussissez par à créer le dictionnaire par compréhension malgré de nombreuses tentatives :
Vous pouvez construire le dictionnaire voulu par extension.
Si vous ne voyez pas comment procéder par extension, vous pouvez utiliser le script suivant à compléter :
```
alpha = ...
for i in range(...): 
    alpha[chr(...)] = ...  # ajout d'une nouvelle association dans le dictionnaire
print(alpha)
```

Le chiffrement de César

À chaque lettre de l'alphabet on associe un nombre de à 0 à 25. On ajoute à ce nombre un nombre entier, par exemple on prend 7 dans la suite des explications.
Le reste de la division euclidienne du nombre obtenue par 26 correspond au chiffre qui codera la lettre initiale.

Par exemple, la lettre "Y" est associée à 24 ; si on lui ajoute 7 on obtient 31. Le reste de la division euclidienne de 31 par 26 est 5. Le nombre 5 correspond à la lettre "F". "Y" est donc codé par "F" dans le chiffrement de César avec un décalage de 7.

Compléter le script print(chr(65+(... + 7)%...)) de sorte que la lettre "F" soit affichée, c'est-à-dire que l'on obtienne la lettre codant "Y" associée au nombre 24 dans le chiffrement de César avec un décalage de 7.
Rappelez vous que le reste de la vision euclidienne de a par b est obtenu en Python avec a%b.
Quels scripts écrire pour obtenir le code de la lettre "A", puis celui de la lettre "W", enfin du mot NSI avec un décalage de 7 ?
Créer un dictionnaire codage associant à chaque lettre de l'alphabet la lettre codée correspondante avec la méthode du chiffrement de César avec un décalage de 7.
Aides possibles en cas de difficultés :
Pour créer le dictionnaire associant à chaque lettre son code en César avec un décalage de 7, il suffit de le faire par compréhension avec le script suivant à compléter :
```
codage = {chr(...): chr(...) for i in range(...)}
print(codage)
```
Autre méthode possible si vous ne réussissez par à créer le dictionnaire par compréhension malgré de nombreuses tentatives :
Vous pouvez construire le dictionnaire voulu par extension.
Si vous ne voyez pas comment procéder par extension, vous pouvez utiliser le script suivant à compléter :
```
codage = ...
for i in range(...): 
    codage[chr(...)] = chr(...)  # ajout d'une nouvelle association dans le dictionnaire
print(codage)
```

En Python, il existe la fonction ord qui prend en paramètre un caractère ASCII et qui renvoie le nombre entier décimal codant ce caractère en ASCII.

Par exemple, ord("A") renvoie 65, ord("Y") renvoie 89 et ord("c") renvoie 99.

Une fonction de codage
1. Reprendre le dictionnaire codage créé précédemment et tester :
```
codage['A']
codage['D']
codage['E']
```
2. Dans le script précédent, quel est le statut de 'A', 'D' et 'E' : clé ou valeur?
3. Écrire une fonction en Python coder qui prend en argument un chaîne de caractères mot écrit en lettre capitale et qui renvoie le mot codé par le chiffrement de César.
  Aides possibles en cas de difficultés :
  1. Créer l'en-tête de la fonction.
  2. Créer une chaîne de caractères réponse vide qui sera progressivement augmentée.
  3. Balayer la chaîne de caractère mot lettre par lettre.
  4. Utiliser le dictionnaire codage pour déterminer le codage de la lettre considérée avec César où le décalage est de 7.
  5. Rajouter la lettre codée à la chaîne de caractères réponse.
  6. Tester la fonction.
  En cas de difficultés, en cliquant ici, il est possible d'obtenir un code à trous à compléter.
  Copier puis compléter le script suivant en vous servant des commentaires et du test proposé ci-dessus.
```
def coder(mot):
code = ...              # chaîne de caractères réponse
for ...:                # balayage de la chaîne mot lettre par lettre
    lettre_codee = ...  # utilisation du dictionnaire codage afin de coder la lettre considérée
    code = code + ...   # rajout de la lettre codée
return code
print(coder("NSI"))
```
  Attention ! Il y a d'autres manières d'écrire le script demandé, manières tout aussi pertinentes que celle proposée ci-dessus avec des trous.

Création à partir de la fonction `dict`

La fonction dict permet la conversion d'une liste de listes à deux éléments en dictionnaire.

Voici un script en langage Python :

liste = [['Achille', 19], ['Bellerophon', 25], ['Camille', 32]]  # liste de 3 listes à deux éléments
d = dict(liste)
print(d)

Deviner le résultat qui sera affiché puis vérifier cela en exécutant le script dans un IDE.

Un dictionnaire est un conteneur pouvant contenir plusieurs associations clef: valeur.
Les clés d'un dictionnaire sont forcément des objets immutables (entier, chaîne de caractères, tuple, ...).
En Python, un dictionnaire est délimité par des accolades, chaque association clef: valeur est séparée des autres par une virgule et chaque valeur est séparée de sa clé par : : dico = {cleF: valeurF, cleD: valeurD, ...}.
Pour rajouter une association new_cle: new_valeur à un dictionnaire dico, il suffit de saisir : dico[new_cle] = new_valeur.
On parle d'extension d'un dictionnaire.
On peut créer un dictionnaire par compréhension avec une structure de la forme : {formule d'association for variable in ensemble (if condition)}
La méthode dict() permet de créer un dictionnaire à d'une liste dont les éléments sont des couples de données.

Interagir avec un dictionnaire

Accéder à une valeur

Accès aux éléments d'un dictionnaire

Accéder aux valeurs associées à une clé

Pour accéder à la valeur d'une clé clef d'un dictionnaire dico, on écrit :

dico[clef]

On donne le dictionnaire suivant :

turing = {'nom': 'Turing', 'prenom': ('Alan', 'Mathison'), 'nation': 'anglaise', 'naissance': 1912, 'mort': 1954}

Si besoin, vous pouvez utiliser le site Trinket.

Afficher les prénoms de Turing.
Afficher sa nationalité.
Déterminer l'âge qu'avait Alan Turing à sa mort.

Voici un exercice à faire en autonomie pour tester votre maîtrise sur l'accès aux éléments d'un dictionnaire.
Cet exercice est issu du site collaboratif de la forge.

Cliquer sur ce lien pour accéder à l'exercice.
Ne pas hésiter à traiter les Versions à compléter.

Modifier un dictionnaire

Pour modifier une valeur d'une clé clef d'un dictionnaire dico, on écrit :

dico[clef] = nouvelle_valeur

Modifier la couleur du pantalon de Bob dans ce dictionnaire :

pantalon_Bob = {'tissu': 'coton', 'taille': '40', 'couleur': 'bleu'}

Nombre d'éléments d'un dictionnaire

Pour connaître la longueur d'un dictionnaire, on utilise la fonction len.

Déterminer le nombre d'éléments dans le dictionnaire contenu dans ce fichier .txt le fichier.

Le personnage d'un jeu vidéo possède dans un sac un ensemble d'objets, chacun possédant sa masse en kilogramme.
Cet ensemble est modélisé par le dictionnaire sac.
On suppose qu'à un moment donné, le personnage possède le sac suivant :
sac = {"potion": 0.01, "pain": 1, "couverture": 2, "couteau": 0.2, "or": 0.1}

Quel code Python permet de savoir la masse d'or présente dans le sac ?
Le personnage trouve un cristal de roche pesant 300 grammes, cristal qu'il décide de stocker dans son sac.
Modifier le sac sac en conséquence.
Ayant faim, le personnage mange 400 grammes de pain extrait de son sac.
Modifier le sac sac en conséquence.
Combien d'objets différents contient le sac du personnage finalement ?

exercice de renforcement

Voici un exercice à faire en autonomie pour tester votre maîtrise sur l'accès, la modification et le nombre d'éléments d'un dictionnaire.
Cet exercice est issu du site collaboratif de la forge.

Cliquer sur ce lien pour accéder à l'exercice.
Ne pas hésiter à traiter la Version à compléter.

Être dans un dictionnaire

Le mot-clé in permet de tester si une clé clef appartient ou non à un dictionnaire dico.
Ainsi clef in dico renvoie True si clef apparaît dans une association du dictionnaire sous forme de clé mais False sinon.

On considère le dictionnaire besace = {"argent": 1524, "couteau": "fer", "fronde": "pierre", "talisman": "or"}.

Sans exécuter l'instruction, deviner la valeur que prend le booléen "argent" in besace.
Sans exécuter l'instruction, deviner la valeur que prend le booléen "or" in besace.
Exécuter les deux instructions afin de vérifier la compréhension de l'utilisation du mot-clé in avec un dictionnaire.

Voici un exercice à faire en autonomie pour tester votre maîtrise sur la manipulation d'un dictionnaire.
Cet exercice est issu du site collaboratif de la forge.

Cliquer sur ce lien pour accéder à l'exercice.
Traiter seulement la fonction depouille.
Ne pas hésiter à traiter la Version à compléter.

Balayage d'un dictionnaire

Dans cette partie, nous allons voir comment itérer sur un dictionnaire avec les 3 méthodes values, keys et items.

La méthode `values()`

La méthode values

Pour obtenir l'ensemble des valeurs sous la forme d'une structure de données itérable d'un dictionnaire dico, on utilise la méthode values.

La donnée structurée ainsi récupérée est de type dict_values, c'est un objet itérable mais non indexé : on peut donc parcourir l'ensemble de ses éléments avec un code comme for elt in d.values():.

Considérons le dictionnaire besace = {"argent": 1524, "couteau": "fer", "fronde": "pierre", "talisman": "or"}.

On peut afficher toutes les valeurs successivement obtenues par balayage avec le script Python suivant :

besace = {"argent": 1524, "couteau": "fer", "fronde": "pierre", "talisman": "or"}
print("Contenu de la besace :")
for val in besace.values():
    print(val)

On obtient comme affichage :

1524
fer
pierre
or

L'ensemble des moyennes obtenues lors d'un trimestre par Bob apparaissent dans le dictionnaire suivant :

res = {"nsi": 18, "maths": 17, "svt": 14, "français": 14, "lv1": 8, "physique": 12, "HG": 11}

Déterminer la moyenne de Bob en créant une fonction moy qui prend en paramètre un dictionnaire res dont les valeurs sont des nombres et qui renvoie le flottant correspondant à la moyenne de ces nombres.

Si besoin, vous pouvez utiliser le site Trinket.

La méthode `keys()`

La méthode keys

Pour obtenir l'ensemble des clés (de type dict_keyss) d'un objet dictionnaire dico, on écrit :

dico.keys()

res = {'nsi': 18, 'maths': 17, 'svt': 14, 'français': 14, 'lv1': 8, 'physique': 12, 'HG': 11}
for cle in res.keys():
	print(cle)

Ce script renvoie l'affichage suivant :

nsi
maths
svt
français
lv1
physique
HG

Il est possible de simplifier l'écriture du balayage for cle in res.keys() par seulement for cle in res puisque le test elt in dico teste si elt est une clé du dictionnaire dico.
Cependant, dans un premier temps, on vous conseille se spécifier le .keys() afin de bien visualiser que vous balayer le dictionnaire par les clés (donc ni par les valeurs, ni par les associations).

Il est conseillé de donner un nom explicitant le rôle ou la nature de la variable stockant l'élément considéré à chaque itération du balayage.
Par exemple, si on considère le dictionnaire associant les gagnants d'un jeu à des jours d'un tournoi :

palmares = {"lundi": ["Adil", "Gilles"], "mardi": ["Paulo"], "mercredi": ["Meredith", "Wanda"], \
            "jeudi": ["Bintou", "Joao", "Erwan"], "vendredi": ["Zineb"]}

Si on balaye le dictionnaire palmares par les valeurs
- Si on veut insister que chaque élément considéré est une valeur du dictionnaire, on peut écrire :
```
for val in palmares.values():
```
- Si on veut insister que chaque élément considéré est de type list puisque les valeurs du dictionnaire considéré en exemple sont des listes, on peut écrire :
```
for liste in palmares.values():
```
Si on balaye le dictionnaire palmares par les clés :
- Si on veut insister que chaque élément considéré est une clé du dictionnaire, on peut écrire :
```
for cle in palmares.keys():
```
- Si on veut insister que chaque élément considéré dans le balayage est un jour de la semaine, on peut écrire :
```
for jour in palmares.keys():
```

On considère un dictionnaire annuaire associant à des noms un numéro de téléphone.
Voici un exemple possible de tel dictionnaire :

annuaire = {
                "Jules": "0645789612",
                "Hugo": "0789456123",
                "Aya": "0629158472",
                "Julie": "0645789612",
                "Arthur": "0735121415"
            }

Proposer une fonction telephoner qui prend en paramètre un dictionnaire contacts du type annuaire ainsi qu'une chaîne de caractères numero et qui renvoie la liste des contacts possédant ce numéro (liste vide si personne de connu ne le possède).

Par exemple :

telephoner(annuaire, "0645789612") renvoie la liste["Jules", "Julie"].
telephoner(annuaire, "0601020304") renvoie la liste[].
telephoner(annuaire, "0629158472") renvoie la liste["Aya"].

Voici un exercice à faire en autonomie pour tester votre maîtrise sur le balayage d'un dictionnaire.
Cet exercice est issu du site collaboratif de la forge.

Cliquer sur ce lien pour accéder à l'exercice.
Ne pas hésiter à lire la correction, que vous ayez réussi ou pas l'exercice.

La méthode `items()`

La méthode items()

Pour obtenir l'ensemble des associations du dictionnaire dico sous forme d'une donnée itérable on utilise la méthode items()

dico.items()

Copier et exécuter le code suivant :

res = {'nsi': 18, 'maths': 17, 'svt': 14, 'français': 14, 'lv1': 8, 'physique': 12, 'HG': 11}
for asso in res.items():
	print(asso)

Que contient la variable asso à chaque itération ?

Copier et exécuter le code suivant :

res = {'nsi': 18, 'maths': 17, 'svt': 14, 'français': 14, 'lv1': 8, 'physique': 12, 'HG': 11}
for c, v in res.items():
	print(c)
    print(v)

Que contiennent les variables c et v à chaque itération ?

Proposer un script court qui permet d'obtenir l'affichage suivant en donnant un nom explicite à la variable ou aux variables servant à stocker l'élément considéré lors du balayage :

J'ai une moyenne de 18 en nsi
J'ai une moyenne de 17 en maths
J'ai une moyenne de 14 en svt
J'ai une moyenne de 14 en français
J'ai une moyenne de 8 en lv1
J'ai une moyenne de 12 en physique
J'ai une moyenne de 11 en HG

exercice de renforcement

Comme on a déjà vu, ar défaut un dictionnaire est itérable mais alors on itère uniquement sur les clés, comme l'illustre le code suivant.
Ce qui peut justifier l'utilité de la méthode items(), lorsque l'on a veut connaître à la fois la clé et la valeur associée, même si la valeur associée à la clé peut être récupérée à partir de la seule clé avec dico[clef].

res = {'nsi': 18, 'maths': 17, 'svt': 14, 'français': 14, 'lv1': 8, 'physique': 12, 'HG': 11}
for elt in res:
	print(elt)

Voici un exercice à faire en autonomie pour tester votre maîtrise sur le balayage d'un dictionnaire.
Cet exercice est issu du site collaboratif de la forge.

Cliquer sur ce lien pour accéder à l'exercice.
Ne pas hésiter à lire la correction, même si vous avez réussi facilement l'exercice afin de visualiser différentes variantes.

Suppression d'une clé

Pour supprimer une association d'un dictionnaire dico, association dont la clé est cle_a_suppr, on peut utiliser la fonction del :

del(d[cle_a_suppr])

On donne le dictionnaire suivant :

res = {"NSI": 18, "maths": 17, "SVT": 14, "français": 14, "LV1": 8, "physique": 12, "HG": 11}

Supprimer l'association liée au français de ce dictionnaire.

exercice de renforcement

Il est préférable de tester au préalable que l'existence de la clé dont on veut supprimer l'association du dictionnaire.

Proposer une fonction supprimer qui prend en paramètres un dictionnaire dico et objet cle qui vérifie si cle est une des clefs du dictionnaire, supprime dans ce cas l'association liée à cette clef alors et renvoie la valeur qui était associée à cette clef cle.

Il existe une méthode native sur les dictionnaires qui permet de supprimer une association cle: valeur et de renvoyer la valeur valeur : c'est la méthode pop().
Voici la structure à utiliser pour cela : dictionnaire.pop(cle).

Copie d'une dictionnaire

Voici une vidéo qui compare deux méthodes pour tenter d'obtenir une copie indépendante d'un dictionnaire et l'explication de ce qui se passe au niveau adresse mémoire :

Comme pour les listes, on ne peut pas copier un dictionnaire en écrivant seulement :

dico1 = dico2

Exécuter le script suivant, comparer les affichages obtenus et expliquer pourquoi la variable dico2 n'est pas la seule à être modifiée.

dicoAmis = {"Amin": 22 , "Bamia": 25 , "Camille": 17}
dico2 = dicoAmis
dico2["Diana"] = 30
print(dicoAmis)
print(dico2)

La méthode copy() permet d'effectuer une vraie copie indépendante d'un dictionnaire.

Modifier le code de l'exercice précédent afin que dico2 soit une vraie copie indépendante du dictionnaire dicoAmis.

dicoAmis = {"Amin": 22 , "Bamia": 25 , "Camille": 17}
dico2 = dicoAmis
dico2["Diana"] = 30
print(dicoAmis)
print(dico2)

Vous devez obtenir comme affichage :

{'Amin': 22, 'Bamia': 25, 'Camille': 17}
{'Amin': 22, 'Bamia': 25, 'Camille': 17, 'Diana': 30}

Opération sur les dictionnaires

L'opérateur & permet de trouver les valeurs communes des données obtenues avec les méthode keys ou items de deux dictionnaires.

Il s'utilise ainsi :

dico1.keys() & dico2.keys()

Deux athlètes s'entraînent sur une semaine pour se préparer à une compétition.
Les deux dictionnaires suivants correspondent au programme d'entraînement de chacun de ces athlètes.

d1 = {'10km': 'lundi', 'fractionné 2h ': 'mardi', '15km': 'mercredi', \
      '1h': 'jeudi', 'musculation': 'vendredi', 'tranquille': 'samedi', 'fractionné 1h ': 'dimanche'}
d2 = {'15km': 'lundi', 'fractionné 2h ': 'mardi', '10km': 'jeudi', \
      '1h': 'jeudi', 'piscine': 'samedi', 'tranquille': 'dimanche'}

Le code suivant renvoie l'ensemble des entraînements similaires aux deux joueurs :

d1.keys() & d2.keys()

On obtient :

{'1h', 'tranquille', '15km', '10km', 'fractionné 2h '}

En reprenant les deux dictionnaires précédents, proposer un script qui permet d'afficher directement les jours où les deux athlètes effectuent le même type d'entraînement le même jour.

Pour accéder à la valeur associée à une clé clef d'un dictionnaire dico, il suffit de saisir : dico[clef].
Pour modifier la valeur associée à une clé clef d'un dictionnaire dico, il suffit de saisir : dico[clef] = new_valeur.
Le nombre d'élément d'un dictionnaire dico est accessible avec la fonction len en saisissant len(dico).
On peut parcourir par itération l'ensemble des clés d'un dictionnaire dico avec la méthode keys() en saisissant for cle in dico.keys():
On peut parcourir par itération l'ensemble des valeurs d'un dictionnaire dico avec la méthode values() en saisissant for valeur in dico.values():
On peut parcourir par itération l'ensemble des association d'un dictionnaire dico avec la méthode items() en saisissant for cle,valeur in dico.items():
Pour supprimer une clé clef (avec sa valeur) d'un dictionnaire dico, il suffit d'utiliser la fonction del avec del(dico[clef]).
Pour créer une copie indépendante dico2 d'un dictionnaire dico, il suffit d'utiliser la méthode copy() avec dico2 = dico.copy().
L'opérateur & permet de trouver les valeurs communes des données obtenues avec les méthode keys, values ou items de deux dictionnaires.

Exercices

Voici une citation célèbre de Gandhi :

La vie est un mystère qu'il faut vivre, et non un problème à résoudre.

Créer un dictionnaire qui associe à chaque lettre (clé) son occurrence (valeur).
Par exemple la lettre 'a' apparaît deux fois.

Par exemple dico = {'a': 2, ...}.

Voici ci-dessous une photo d'un cygne. Le but de l'exercice est d'obtenir à partir d'un script en Python des informations sur cette photo, en particulier :

Depuis quel appareil a été prise la photo ?
Quand a été prise la photo ?
En quel endroit ?

Pour travailler avec une image, vous allez vous servir d'une bibliothèque de Python nommée PIL.
Entre autre, elle permet d'extraire les données Exif rattachées à une image avec la méthode "protégée" _getexif().
Cette méthode renvoie sous forme d'un dictionnaire le fichier Exif.

Les métadonnées (résolution, auteur, type d'appareil photo, coordonnées GPS) sont associée à un fichier image en tant que données Exif.
Vous pouvez retrouver des travaux faits en SNT dessus à cette adresse.

Télécharger le fichier image du cygne et l'installer dans le répertoire courant de travail de l'IDLE que vous utilisez pour exécuter des scripts en Python.

Exécuter le programme ci-dessous et rajouter une ligne de code permettant de connaître le type de la variable donneesExif, variable stockant l'ensemble des données Exif de l'image.

# importation de la bibliothèque PIL
import PIL.Image
# ouverture de l'image
image = PIL.Image.open('cygne.jpg')
# Extraction des données Exif stockées dans une variable donneesExif
donneesExif = image._getexif()

Afficher l'ensemble des données Exif liées à l'image du cygne.
Quelle est le type des clés rencontrées ?
À chaque clef du dictionnaire, une information est liée en valeur.
L'ensemble des relations clef: valeur est imposé dans le standard Exif 2.3. Si vous voulez découvrir cet ensemble de références, vous pouvez visiter le site suivant, en anglais : standard Exif 2.3.
Nous allons nous intéresser à quelques informations :
- le copyright est accessible avec la clé 33432,
- la sensibilité ISO utilisée lors de la prise de vue est accessible avec la clé 34855,
- la marque de l'appareil utilisé est accessible avec la clé 271,
- le type de l'appareil utilisé est accessible avec la clé 272.
Proposer un script qui affiche la sensibilité utilisée ainsi que la marque et le type d'appareil ayant servi à prendre la photo.
La clef 36867 permet de connaître la date et l'heure où a été prise la photo.
Écrire un script ci-dessous permettant de connaître cette information.
Il reste à trouver le lieu où la photo a été prise.
Pour cela, il suffit d'utiliser la clé 34853 qui est associer à un dictionnaire dont :
- La clé 1 permet de connaître l'hémisphère : 'N' signifie hémisphère nord et 'S' signifie hémisphère sud,
- La clé 2 permet d'accéder à un tuple contenant la latitude GPS sexagésimale du lieu de la prise de vue ; le premier tuple correspond aux degrés, le deuxième aux minutes et le dernier aux secondes.
- La clé 3 permet de connaître le type de longitude : 'E' signifie longitude Est et 'O' signifie longitude Ouest.
- La clé 4 permet d'accéder à un tuple contenant la longitude GPS sexagésimale du lieu de la prise de vue ; le premier tuple correspond aux degrés, le deuxième aux minutes et le dernier aux secondes.
Attention ! Latitude et longitude sont stockées dans un format fractionnaire : par exemple, le tuple (44, 1) correspond bien au nombre 44 tandis que le tuple (1431,50) correspond au nombre $\frac{1431}{50}$ soit 28.62.

Proposer une procédure get_latitude qui a pour argument le dictionnaire obtenu avec la clé 34853 et qui affiche la latitude GPS du lieu.
Cette latitude sera de type chaîne de caractères et écrite sous la forme : 01° 23' 45.67''.
Déterminer la longitude du lieu de la prise de la photo.
Utiliser un site Web vous permettant de trouver l'endroit où la photo a été prise à partir des coordonnées GPS obtenues.
Sur quelle rivière nage le cygne de la photo ?

On considère la fonction numero ci-dessous qui prend en paramètre un dictionnaire dico associant des noms de personnes (de type str) à leur numéro de téléphone (de type int).

Exercices de renforcement

Bob a ce trimestre obtenu les moyennes suivantes, moyennes classées dans le dictionnaire suivant :

res = {"NSI": 18, "maths": 17, "SVT": 14, "français": 14, "LV1": 8, "physique": 12, "HG": 11}

Il manque à cet ensemble la LV2 où Bob a obtenu une moyenne de 12.
Rajouter cette matière et sa moyenne au dictionnaire res.

Cliquer pour afficher la solution

Il suffit de saisir pour ajouter l'association "LV2": 12 au dictionnaire :

res["LV2"] = 12

Un personnage d'un jeu vidéo possède une carte personnelle sur laquelle il peut faire apparaître certains noms de lieux à partir des coordonnées connues de ceux-ci.

À un moment du jeu, ce personnage veut faire apparaître sur cette carte les lieux suivants :

"source_de_jouvence" située au point de coordonnées $(45;195)$.
"portail" situé au point de coordonnées $(207;318)$.
"base_secrete" située au point de coordonnées $(624;18)$.

Pour implémenter ces informations, le programmeur du jeu à utiliser un dictionnaire carte contenant chaque association "nom_du_lieu":coordonnées, les coordonnées étant saisies sous forme d'un tuple.

Quel script Python saisir pour créer le dictionnaire carte afin qu'il contienne les trois lieux mentionnés ci-dessus ?
Quel code Python suffit-il de saisir afin d'obtenir les coordonnées de la base secrète à partir du dictionnaire carte ?
La source de jouvence initiale est épuisée. Par chance, le personnage en découvre une nouvelle positionnée au point de coordonnées $(362;129)$.
Quel code Python saisir pour mettre à jour le dictionnaire carte ?
Le personnage découvre l'entrée du château très intéressant en $(475;390)$.
Quel code Python saisir pour rajouter ce lieu au dictionnaire carte ?
Quel code Python saisir pour connaître le nombre de lieux présents dans le dictionnaire carte ?

Cliquer pour afficher la solution

Pour créer le dictionnaire carte avec les trois lieux, il suffit de saisir :
```
carte = {"source_de_jouvence": (45, 195), "portail": (207, 318), "base_secrete": (624, 18)}
```
Attention à bien mettre des tuples comme valeurs en séparant chaque coordonnée par une virgule au lieu d'un point-virgule !
Pour obtenir les coordonnées de la base secrète à partir du dictionnaire carte , il suffit de saisir :
```
carte["base_secrete"]
```
Pour mettre à jour les coordonnées de la source de jouvence du dictionnaire carte, il suffit de saisir :
```
carte["source_de_jouvence"] = (362,129)
```
Pour rajouter l'entrée du château au dictionnaire carte, il suffit de saisir :
```
carte["entree_chateau"] = (475,390)
```
Pour connaître le nombre de lieux présents dans le dictionnaire carte, il suffit de saisir :
```
len(carte)
```

Le personnage d'un jeu vidéo possède dans un sac un ensemble d'objets, chacun possédant une masse en kilogramme.
Cet ensemble est modélisé par le dictionnaire sac.
On suppose qu'à un moment donné, le personnage possède le sac suivant : sac = {"potion": 0.01, "pain": 1, "couverture": 2, "couteau": 0.2, "or": 0.1}

Proposer un script Python qui permet de créer la liste objets de tous les objets présents dans le dictionnaire sac.

Itérer sur le dictionnaire et créer la liste objets par extension.
Proposer un script Python qui permet de connaître la masse totale du sac sac, sachant que le sac vide possède une masse de 1 kilogramme.

Cliquer pour afficher la solution

Voici un script Python qui permet de créer la liste objets de tous les objets présents dans le dictionnaire sac.

sac = {"potion": 0.01, "pain": 1, "couverture": 2, "couteau": 0.2, "or": 0.1}

objets = []
for elt in sac.keys():
    objets.append(elt)
print(objets)

Voici un script Python qui permet de connaître la masse totale du sac, sachant que le sac vide possède une masse de 1 kilogramme.

sac = {"potion": 0.01, "pain": 1, "couverture": 2, "couteau": 0.2, "or": 0.1}

masse = 1       # masse du sac vide
for kg in sac.values():
    masse = masse + kg
print(masse)

Pour s'alléger, le personnage décide de donner à un manant sa couverture.
Quel code Python permet de supprimer la couverture du sac sac ?

Cliquer pour afficher la solution

Il suffit de saisir pour supprimer l'association "couverture":2 au dictionnaire :

del(sac["couverture"])

Les projets

Vous avez à réaliser un mini-projet en langage Python qui utilise les principes développés sur DC1 et DC2. Vous devez utiliser des listes et/ou tuples et des dictionnaires.

inventer un jeu de cartes en réutilisant le jeu de cartes implémenté dans DC1 ;
continuer le travail de cryptographie ;
continuer le travail sur l'analyse de textes, créer un dictionnaire des mots utilisés dans un texte avec leur fréquence ;
trouver l'origine linguistique d'un texte en analysant les fréquences des lettres utilisées ;
inventer votre propre projet.

Nous constituerons des groupes de 2-3 personnes. Vous devrez, pour ce projet, réaliser une vidéo personnelle de 3-4 minutes présentant votre travail.

QCM

Questions issues de la Banque Nationale de Sujets

Propriétaire des ressources ci-dessous : ministère de l'Éducation nationale et de la jeunesse, licence CC BY SA NC

Voici une sélection de questions issues de la banque nationale de sujets, répondez à ces questions (attention, cette sélection n'est pas exhaustive).

On définit ainsi une liste P :

P = [{"nom": "Turing", "prénom": "Alan", "âge": 28},
     {"nom": "Lovelace", "prénom": "Ada", "âge": 27}]

Que fait alors l'instruction P[1]["âge"] = 25 ?

Réponses :

A- Elle modifie la valeur de la clé âge du deuxième élément de la liste P.

B- Elle modifie la valeur de la clé âge du premier élément de la liste P.

C- Elle donne la longueur de la liste P.

D- Elle donne la longueur du premier élément de la liste P.

On définit ainsi une liste P :

P = [{"nom":"Turing", "prénom": "Alan", "âge": 28},
     {"nom": "Lovelace", "prénom": "Ada", "âge": 27} ]

Comment accéder à la chaîne de caractères "Alan" ?

Réponses :

A- P[0].

B- P[1].

C- P[0]["prénom"].

D- P[1]["prénom"].

On considère le dictionnaire

D = {1: 3, 2: 4, 3: 5, 4: 2, 5: 1}

Quelle est la valeur de D[D[D[2]]] ?

Réponses :

A- 2

B- 3

C- 4

D- 5

On définit un dictionnaire :

d = {'couleur': 'vert', 'taille': 42, 'marque': 'le coq sportif'}

Quelle est la valeur de l'expression d.keys() ?

Réponses :

A- ['couleur', 'taille', 'marque'].

B- [('couleur', 'vert'), ('taille', 42), ('marque', 'le coq sportif')].

C- ['vert', 42, 'le coq sportif'].

D- ['couleur': 'vert', 'taille': 42, 'marque': 'le coq sportif'].

On définit une table d'élèves et une liste finale de la façon suivante :

table_eleves = [{"prenom": "Ada", "nom": "Lovelace", "age": 17},
                {"prenom": "Charles", "nom": "Babbage", "age": 18},
    ...
                {"prenom": "John", "nom": "Von Neumann", "age": 16}]

liste_finale = [eleve for eleve in table_eleves if eleve["age"] >= 18]

Que contient cette liste finale ?

Réponses :

A- La liste des prénoms des élèves majeurs de la table.

B- La liste des âges des élèves majeurs de la table.

C- La liste des élèves majeurs de la table, chaque élément de la liste étant représenté par un dictionnaire.

D- La liste des élèves majeurs de la table, chaque élément de la liste étant représenté par une liste.

On dispose du dictionnaire regions ci-dessous :

regions = {'Mayotte': 376,
           'Pays de la Loire': 32082,
           'La Réunion': 2504,
           'Grand Est': 57441,
           'Martinique': 1128,
           'Corse': 8680,
           'Bretagne': 27208,
           'Nouvelle-Aquitaine': 84036}

Parmi les instructions suivantes, laquelle permet d'ajouter une nouvelle région ?

Réponses :

A- INSERT "'Hauts de France':31806" INTO regions.

B- regions = dict(['Hauts de France'] = 31806).

C- regions('Hauts de France') = 31806.

D- regions['Hauts de France'] = 31806.

On définit le dictionnaire suivant :

d = {'A': 3, 'B': 7, 'C': 2}

Quelle expression permet de récupérer la valeur de la clé 'B' ?

Réponses :

A- d['B'].

B- d[1].

C- d[7].

D- d[B].

On définit les notes des élèves dans le dictionnaire suivant :

notes = {'Pierre' : 9, 'Paule' : 16, 'Claire' : 12, 'Sophie' : 11, 'Yasmine' : 8, 'David' : 17, 'Julie' : 3}

Quelle expression permet d'accéder à la note de l’élève Claire ?

Réponses :

A- notes[12].

B- notes[2].

C- notes['Claire'].

D- notes.values('Claire').

On définit ainsi une liste t :

t = [{'id':1, 'age':23, 'sejour':'PEKIN'},
     {'id':2, 'age': 27, 'sejour': 'ISTANBUL'},
     {'id':3, 'age': 53, 'sejour': 'LONDRES'},
     {'id':4, 'age': 41, 'sejour': 'ISTANBUL'},
     {'id':5, 'age': 62, 'sejour': 'RIO'},
     {'id':6, 'age': 28, 'sejour': 'ALGER'}]

Quelle affirmation est correcte ?

Réponses :

A- t est une liste de listes.

B- t est une liste de dictionnaires.

C- t est un dictionnaire de listes.

D- t est un dictionnaire de dictionnaires.

On définit le dictionnaire dico par les instructions suivantes : :

def f(x):
    return x*x

def g(x):
    return x + x

def h(x):
    return 3*x

dico = {'F': f, 'G': g(6), 'H': h}

Une seule des affirmations suivantes est incorrecte. Laquelle ?

Réponses :

A- dico['F'] est une fonction.

B- dico['F'](5) est un entier.

C- dico['G'] est une fonction.

D- dico['G'] est un entier.

Autres QCM

Les QCM suivants sont issus de https://genumsi.inria.fr.

Quelle est la valeur affichée par l'exécution du script suivant ?

ports = {'ftp' : 21, 'http' : 80}
ports['imap'] = 142
print(ports)

Réponses :

A- {'ftp': 21, 'http': 80}

B- {'ftp': 21, 'http': 80, 'imap': 142}

C- {'imap': 142}

D- Key not found

On dispose d'un dictionnaire et d'une liste :

T = {'Bill': '06 05 04 03 02', 'Roger': '06 12 11 13 20', 'Marilla': '07 00 01 02 03', 'James': '07 00 70 00 70'}
lst = [x for x in T if T[x][:2] == '06']

Que contient lst à la fin de l’exécution de ce script ?

Réponses :

A- ['06']

B- ['06 05 04 03 02', '06 12 11 13 20']

C- ['Bill' : '06 05 04 03 02', 'Roger': '06 12 11 13 20']

D- ['Bill', 'Roger']

(Auteur : Germain BECKER)

On considère le dictionnaire repertoire suivant :

repertoire = {'Marc':'0101', 'Virginie':'0202', 'Justine':'0303'}

Que renvoie l'instruction '0202' in repertoire ?

Réponses :

A- False.

B- True.

C- 'Virginie'.

D- 'Virginie':'0202'

(Auteur : Germain BECKER)

Qu'affiche le programme suivant ?

rep = {'Jean': 123, 'Jenifer': 124, 'Samuel': 125, 'Lisa': 126}
rep['Clara'] = 127
for cle in rep.keys():
    print(cle)

Réponses :

A- 'Clara'.

B- 'Jean', 'Jenifer', 'Samuel', 'Lisa' et 'Clara'.

C- 127.

D- 123, 124, 125, 126 et 127.

(Auteur : Guillaume CONNAN)

On dispose du dictionnaire suivant :

Tel = {'Bill': '06 05 04 03 02', 'Roger': '06 12 11 13 20'}

Comment obtenir la liste des numéros de téléphones ?

Réponses :

A- list(Tel).

B- list(Tel.values()).

C- list(Tel.keys()).

D- list(Tel.items()).

(Auteur : Guillaume CONNAN)

On dispose du dictionnaire suivant :

Tel = {'Bill': '06 05 04 03 02', 'Roger': '06 12 11 13 20'}

Quelle instruction permet de modifier le dictionnaire de façon à ce que sa nouvelle valeur soit l'objet ci-dessous ?

{'Bill': '06 05 04 03 02', 'Roger': '06 12 11 13 20', 'Marilla': '07 01 02 03 04'}

Réponses :

A- dico['Marilla'] = '07 01 02 03 04'.

B- dico.append('Marilla', '07 01 02 03 04').

C- dico['Marilla'] += '07 01 02 03 04'.

D- ce n'est pas possible car un dictionnaire n'est pas modifiable.

(Autrice : Christelle BRIEC)

Comment peut-on accéder à la valeur associée à une clé dans un dictionnaire ?

Réponses :

A- Il faut parcourir le dictionnaire avec une boucle à la recherche de la clé.

B- On peut y accéder directement à partir de la clé.

C- On ne peut pas accéder à une valeur contenue dans un dictionnaire à partir d’une clé.

D- Il faut d’abord déchiffrer la clé pour accéder à un dictionnaire.

(Auteur : David Planchet)

Voici un dictionnaire de langues :

dico = {'anglais': 'english', 'allemand': 'deutsch', 'breton': 'brezhoneg'}

Quelle est la valeur de dico[1] ?

Réponses :

A- rien car l'expression est invalide.

B- 'english'.

C- 'deutsch'.

D- 'allemand'.

(Auteur : David Planchet)

Voici un dictionnaire de langues :

dico = {'anglais': 'english', 'allemand': 'deutsch', 'breton': 'brezhoneg'}

On souhaite ajouter une langue en plus et obtenir le dictionnaire suivant :

dico = {'anglais': 'english', 'allemand': 'deutsch', 'breton': 'brezhoneg', 'espagnol': 'español'}

Quelle instruction permet d'ajouter le dernier élément 'espagnol': 'español' dans le dictionnaire ?

Réponses :

A- Ce n'est pas possible car un dictionnaire n'est pas modifiable.

B- dico.append('espagnol': 'español').

C- dico['espagnol'] = 'español'.

D- dico += ['espagnol': 'español'].

(Auteur : David Planchet)

Voici un dictionnaire de langues :

dico = {'anglais': 'english', 'allemand': 'deutsch', 'breton': 'brezhoneg'}

On souhaite ajouter une langue en plus et obtenir le dictionnaire suivant :

for elem in dico.items():
    print(elem, end=' ')

Quel est l'affichage lors de l'exécution du code précédent ?

Réponses :

A- anglais allemand breton .

B- english deutsch brezhoneg .

C- ('anglais', 'english') ('allemand', 'deutsch') ('breton', 'brezhoneg') .

D- une erreur.

(Auteur : Guillaume Connan)

On dispose du dictionnaire suivant :

Tel = {'Bill': '06 05 04 03 02', 'Roger': '06 12 11 13 20'}

Quels sont les affichages possibles lors de l'exécution de ce code ?

for truc in dico.items():
    print(truc, end=' ')

Réponses :

A- Bill Roger.

B- 06 05 04 03 02 06 12 11 13 20.

C- ('Bill', '06 05 04 03 02') ('Roger', '06 12 11 13 20').

D- Bill end Roger end.

(Auteur : Guillaume Connan)

On dispose d'une table de données table représentée par une liste de dictionnaires. En entrant table[0] on obtient:

Réponses :

A- Une ligne.

B- Une colonne.

C- Une cellule.

D- Une erreur

(Auteur : Adrien WILLM)

On considère la fonction suivante dont la fin est manquante.

def mois(n) :
    '''
    Transforme un mois donné sous forme d'un entier en une chaîne de caractères où le mois est écrit en toutes lettres.
    param n : (int) entier compris entre 1 et 12 correspondant à un mois de l'année
    return (str) : chaîne de caractères correspondant au mois en toutes lettres
    '''
    dico1 = {1: 'Janv.', 2: 'Fév.', 3: 'Mars', 4: 'Avr.', 5: 'Mai', 6: 'Juin',
             7: 'Juil.', 8: 'Aout', 9: 'Sept.', 10: 'Oct.', 11: 'Nov.', 12: 'Déc.'}
    dico2 = {'Janv.': 1, 'Fév.': 2,'Mars': 3, 'Avr.': 4, 'Mai': 5, 'Juin': 6,
             'Juil.': 7, 'Aout': 8, 'Sept.': 9, 'Oct.': 10, 'Nov.': 11, 'Déc.':  12}
    return ...

Par quel code faut-il remplacer les … après le return pour que la fonction soit correcte ?

Réponses :

A- dico1(n).

B- mois.

C- dico1[n].

D- dico2{n}.

Générateur aléatoire de questions sur ce chapitre

Il faut actualiser la page pour changer de question. Propriétaire de la ressource : le site GeNumsi en licence CC BY_NC-SA

Savoir-faire et Savoir

Savoir construire des dictionnaires. (cf. propriété 1).
Savoir construire d'un bloc un dictionnaire. (cf. exercice 3).
Savoir étendre un dictionnaire. (cf. exercice 4).
Savoir comprendre la création par compréhension d'un dictionnaire. (cf. exercice 6).
Savoir construire un dictionnaire par compréhension. (cf. exercice 7).
Savoir accéder aux valeurs d'un dictionnaire. (cf. exercice 9).
Savoir modifier une valeur d'un dictionnaire. (cf. exercice 10).
Savoir compter le nombre d'éléments d'un dictionnaire. (cf. exercice 11).
Savoir tester si une clef appartient ou non à un dictionnaire (cf. exercice 13).
Savoir itérer sur un dictionnaire avec les méthodes keys(), values() et items(). (cf. exercices 15, 14 et 16).
Savoir supprimer une valeur d'un dictionnaire. (cf. exercice 17).
Savoir créer une copie indépendante d'un dictionnaire. (cf. exercice 20).
Savoir modéliser un problème concret en utilisant une structure de dictionnaire (cf. exercice 19).

Savoir le vocabulaire sur les dictionnaires (dictionnaire, clé, valeur, association). (cf. définition 1).
Savoir que les clés d'un dictionnaire doivent être des objets immutables. (cf. définition 1).
Savoir qu'un dictionnaire est un conteneur mutable. (cf. propriété 2).
Savoir la différence entre une copie par duplication du nom de la variable (avecdico1=dico2).

dico2=dico1.copy()

Les différents auteurs mettent l'ensemble du site à disposition selon les termes de la licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International

▲

Introduction

Les types construits : les dictionnaires Tableaux associatifs

Définition

Construire d'un bloc un dictionnaire

Création de dictionnaire par extension

Création en compréhension

Création à partir de la fonction dict

Interagir avec un dictionnaire

Accéder à une valeur

Accès aux éléments d'un dictionnaire

Modifier un dictionnaire

Nombre d'éléments d'un dictionnaire

Être dans un dictionnaire

Balayage d'un dictionnaire

La méthode values()

La méthode keys()

La méthode items()

Suppression d'une clé

Copie d'une dictionnaire

Opération sur les dictionnaires

Exercices

Exercices de renforcement

Les projets

QCM

Questions issues de la Banque Nationale de Sujets

Autres QCM

Générateur aléatoire de questions sur ce chapitre

Savoir-faire et Savoir

Création à partir de la fonction `dict`

La méthode `values()`

La méthode `keys()`

La méthode `items()`